#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>
#include <exception>
#include "apps.inc.h"
#include "tests.inc.h"


#define TAMBLOQUE 210
#define POS1 4
#define POS2 16
#define POS3 32


using namespace std;


void testAD(){    
    PrimaryKeyPersona *PK = new PrimaryKeyPersona();
    Persona *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10;    
    char nombre1[] = "primeroji", nombre2[] = "segundojj", nombre3[] = "tercero", nombre4[] = "cuarto", nombre5[] = "quinto",
    nombre6[] = "sexto", nombre7[] = "septimo", nombre8[] = "octavo", nombre9[] = "noveno", nombre10[] = "decimo";
    char dni1[] = "11111111", dni2[] = "22222222", dni3[] = "33333333", dni4[] = "44444444", dni5[] = "55555555", 
    dni6[] = "66666666", dni7[] = "77777777", dni8[] = "88888888", dni9[] = "99999999", dni10[] = "10101010";
    char apellido[] = "perezgggg";
    
    p1 = new Persona(nombre1,apellido,dni1);
	p2 = new Persona(nombre2,apellido,dni2);
	p3 = new Persona(nombre3,apellido,dni3);
	p4 = new Persona(nombre4,apellido,dni4);
	p5 = new Persona(nombre5,apellido,dni5);
	p6 = new Persona(nombre6,apellido,dni6);
	p7 = new Persona(nombre7,apellido,dni7);
	p8 = new Persona(nombre8,apellido,dni8);
	p9 = new Persona(nombre9,apellido,dni9);
	p10 = new Persona(nombre10,apellido,dni10);    
	
	char path[]="./test.bin";
	//FabRecAlmacenamiento *f=new FabRecAlmacenamiento(); 
	RecursoDeAlmacenamiento *rec = FabRecAlmacenamiento::recursoArchivo_IndiceArbol(path, FIJA, REGISTROS, PK);
 //RecursoDeAlmacenamiento *rec = FabRecAlmacenamiento::recursoBuffer_IndiceArbol(FIJA, REGISTROS, 512,PK);
    try{	
         rec->insertar(p1);
         rec->insertar(p2);
         rec->insertar(p3);
         rec->insertar(p4);
         rec->insertar(p5); printf("\nFIN");
         rec->insertar(p6);
         rec->insertar(p7);
         rec->insertar(p8);
         rec->insertar(p9);
         rec->insertar(p10);
 
    }
    catch(exception *e){
        printf("%s",e->what());
    }
    
    try{
        rec->leer(p1);        
        p1->print();
    }
    catch(exception *e){
        printf("%s",e->what());
    }
    char nombre11[]="juan";
    char ape1[]="gomez";
    Persona *p11 = new Persona(nombre11,ape1,dni1);
    rec->modificar(p11);
    
    char n[]="algo",a[]="mas";
    Persona *p12 = new Persona(n,a,dni3);
    
    
    try{
    	rec->leer(p1);        
        p1->print();
    	
        rec->leer(p12);        
        p12->print();
    }
    catch(exception *e){
        printf("%s",e->what());
    }
	rec->eliminar(p7);
	/*	
	try{
        rec->leer(p7);        
        printf("ERROR, DEBERIA HABERLO BORRADO");
    }
    catch(exception *e){
        printf("PERSONA ELIMINADA");
    }
    */
    delete(rec);
    delete(p1);
    delete(p2);
    delete(p3);
    delete(p4);
    delete(p5);
    delete(p6);
    delete(p7);
    delete(p8);
    delete(p9);
    delete(p10);
    delete(p11);
    delete(PK); 
    
    printf("\nFIN");
}

void testAB(){    
    PrimaryKeyPersona *PK = new PrimaryKeyPersona();
    Persona *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10;    
    char nombre1[] = "primeroji", nombre2[] = "segundojj", nombre3[] = "tercero", nombre4[] = "cuarto", nombre5[] = "quinto",
    nombre6[] = "sexto", nombre7[] = "septimo", nombre8[] = "octavo", nombre9[] = "noveno", nombre10[] = "decimo";
    char dni1[] = "11111111", dni2[] = "22222222", dni3[] = "33333333", dni4[] = "44444444", dni5[] = "55555555", 
    dni6[] = "66666666", dni7[] = "77777777", dni8[] = "88888888", dni9[] = "99999999", dni10[] = "10101010";
    char apellido[] = "perezgggg";
    
    p1 = new Persona(nombre1,apellido,dni1);
	p2 = new Persona(nombre2,apellido,dni2);
	p3 = new Persona(nombre3,apellido,dni3);
	p4 = new Persona(nombre4,apellido,dni4);
	p5 = new Persona(nombre5,apellido,dni5);
	p6 = new Persona(nombre6,apellido,dni6);
	p7 = new Persona(nombre7,apellido,dni7);
	p8 = new Persona(nombre8,apellido,dni8);
	p9 = new Persona(nombre9,apellido,dni9);
	p10 = new Persona(nombre10,apellido,dni10);    
	
//	char path[]="./test.bin";
	//FabRecAlmacenamiento *f=new FabRecAlmacenamiento(); 
//	RecursoDeAlmacenamiento *rec = FabRecAlmacenamiento::recursoArchivo_IndiceArbol(path, FIJA, REGISTROS, PK);
 RecursoDeAlmacenamiento *rec = FabRecAlmacenamiento::recursoBuffer_IndiceArbol(FIJA, REGISTROS, 512,PK);
    try{	
         rec->insertar(p1);
         rec->insertar(p2);
         rec->insertar(p3);
         rec->insertar(p4);
         rec->insertar(p5);
         rec->insertar(p6);
         rec->insertar(p7);
         rec->insertar(p8);
         rec->insertar(p9);
         rec->insertar(p10);
 
    }
    catch(exception *e){
        printf("%s",e->what());
    }
    
    try{
        rec->leer(p1);        
        p1->print();
    }
    catch(exception *e){
        printf("%s",e->what());
    }
    char nombre11[]="juan";
    char ape1[]="gomez";
    Persona *p11 = new Persona(nombre11,ape1,dni1);
    rec->modificar(p11);
    
    char n[]="algo",a[]="mas";
    Persona *p12 = new Persona(n,a,dni3);
    
    
    try{
    	rec->leer(p1);        
        p1->print();
    	
        rec->leer(p12);        
        p12->print();
    }
    catch(exception *e){
        printf("%s",e->what());
    }
	rec->eliminar(p7);
	/*	
	try{
        rec->leer(p7);        
        printf("ERROR, DEBERIA HABERLO BORRADO");
    }
    catch(exception *e){
        printf("PERSONA ELIMINADA");
    }
    */
    delete(rec);
    delete(p1);
    delete(p2);
    delete(p3);
    delete(p4);
    delete(p5);
    delete(p6);
    delete(p7);
    delete(p8);
    delete(p9);
    delete(p10);
    delete(p11);
    delete(PK); 
     printf("\nFIN");
}








void test_Est_Reg_Buf_Fija(){
	cout<<"Iniciando test: Estrategia Registros"<<endl;
	Persona *p1, *p2,*p3, *p4,*p5, *p6, *p7, *p8,*p9,*p10;
	 char nombre1[] = "primero", nombre2[] = "segundo", nombre3[] = "tercero", nombre4[] = "cuarto", nombre5[] = "quinto",
    nombre6[] = "sexto", nombre7[] = "septimo", nombre8[] = "octavo", nombre9[] = "noveno", nombre10[] = "decimo";
    char dni1[] = "11111111", dni2[] = "22222222", dni3[] = "33333333", dni4[] = "44444444", dni5[] = "55555555", 
    dni6[] = "66666666", dni7[] = "77777777", dni8[] = "88888888", dni9[] = "99999999", dni10[] = "10101010";
    char apellido[] = "perez";
	vector<Dato*> vecd;	
	int pos1;
		
	p1 = new Persona(nombre1,apellido,dni1);
	p2 = new Persona(nombre2,apellido,dni2);
	p3 = new Persona(nombre3,apellido,dni3);
	p4 = new Persona(nombre4,apellido,dni4);
	p5 = new Persona(nombre5,apellido,dni5);
	p6 = new Persona(nombre6,apellido,dni6);
	p7 = new Persona(nombre7,apellido,dni7);
	p8 = new Persona(nombre8,apellido,dni8);
	p9 = new Persona(nombre9,apellido,dni9);
	p10 = new Persona(nombre10,apellido,dni10);  
	
	Buffer::getInstance()->setTamanio(512*sizeof(char));//guardo lugar para 512 bytes	
		
	Almacenamiento **alm = (Almacenamiento**)malloc(2*sizeof(Almacenamiento*));//new AlmacenamientoBuffer(new Compuesto());
	
	alm[0]= new AlmacenamientoBuffer(new Compuesto());
		
	EstrategiaRegistros *EReg = new EstrategiaRegistros(alm, BUFFER);	
	
	EReg->crear(FIJA, vecd, Buffer::getInstance()->getPointer());

	try{
	
	EReg->insertar(p1, &pos1);
	}catch(exception &e){
		printf("p1= %s",e.what());
	}
	
	try{
	int pos2;
	EReg->insertar(p2, &pos2);
	EReg->insertar(p3, &pos1);
	EReg->insertar(p4, &pos1);
	EReg->insertar(p5, &pos1);
	EReg->insertar(p6, &pos1);
	EReg->insertar(p7, &pos1);
	EReg->insertar(p8, &pos1);
	EReg->insertar(p9, &pos1);
	EReg->insertar(p10, &pos1);
	}catch(exception &e){
		printf("%s",e.what());
	}
	
	Persona  *p12, *p13;
	//p11 = new Persona();
	char naux[]="alguno", apaux[]="lopez";
	p12 = new Persona(naux,apaux,dni8);
	
	char n[]="",a[]="";
	p13 = new Persona(n,a,dni8);
	
	//printf("leo (el 1ero): \n");
	//EReg->leer(p11);
	//p11->print();printf("\n");

	printf("leo (con la clave 88888888 al cual modifique previamente): \n");
	
	EReg->modificar(p12);
	EReg->leer(p13);
	
	p13->print();printf("\n");
	
	printf( "cant componentes= %d\n", alm[0]->getCompuesto()->getCantidadComponentes());

	printf("Elimino dos componentes\n");
	EReg->eliminar(p12,0); // pos 7
	EReg->eliminar(p4,0); // pos 3

	
	printf( "cant componentes= %d\n", alm[0]->getCompuesto()->getCantidadComponentes());
	
	delete(EReg);
	delete(Buffer::getInstance());
	
	free(p2);
	free(p3);
	free(p4);
	cout<<"Terminado test"<<endl<<endl;
	return;
}




void testBloqueRegistros(){ // memoria
	cout<<"Iniciando test Bloque Registro en memoria"<<endl;
	Persona *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8;
	char nombre1[] = "primero", nombre2[] = "segundo", nombre3[] = "tercero",
	nombre4[] = "cuarto", nombre5[] = "quinto", nombre6[] = "sexto",
	nombre7[] = "septimo", nombre8[] = "octavo", apellido[] = "perez";
	char dni1[] = "11111111", dni2[] = "22222222", dni3[] = "33333333", dni4[] = "44444444",
	dni5[] = "55555555", dni6[] = "66666666", dni7[] = "77777777", dni8[] = "88888888";

	p1 = new Persona(nombre1,apellido,dni1);
	p2 = new Persona(nombre2,apellido,dni2);
	p3 = new Persona(nombre3,apellido,dni3);
	p4 = new Persona(nombre4,apellido,dni4);
	p5 = new Persona(nombre5,apellido,dni5);
	p6 = new Persona(nombre6,apellido,dni6);
	p7 = new Persona(nombre7,apellido,dni7);
	p8 = new Persona(nombre8,apellido,dni8);
	
	printf("\n BUFFER:\n");
		
		
	/* quiero:
	 * 					bloque1						bloque2
	 * 		/---------------------------/---------------------------/
	 * 		|	|	|	|	|	|	|	|	|	|	|	|	|	|	|
	 * 		  -   1   -   3   2   5   -   4   -   6   -   7   8   -
	 */	
	
	// en memoria
	
	Bloque *b1,*b2;
	char* buffer;
	int tamBuffer = 500;
	buffer = (char*) malloc(sizeof(char)*tamBuffer);
	b1 = new BloqueMemoria(FIJA,TAMBLOQUE,1,(void*)buffer);
	char *segundoBloque;
	segundoBloque = (char*)buffer+TAMBLOQUE;
	b2 = new BloqueMemoria(FIJA,TAMBLOQUE,2,(void*)segundoBloque);
	
	Registro *r1,*r2,*r3,*r4,*r5,*r6,*r7,*r8;
	void* offset=NULL;
	b1->getAccesoDato(&offset);
	offset = (char*) offset + 30;
	r1 = new RegistroMemoria(FIJA,p1->getTamanio(BINARIO),offset,p1);
	offset = (char*) offset + 60;
	r3 = new RegistroMemoria(FIJA,p3->getTamanio(BINARIO),offset,p3);
	offset = (char*) offset + 30;
	r2 = new RegistroMemoria(FIJA,p2->getTamanio(BINARIO),offset,p2);
	offset = (char*) offset + 30;
	r5 = new RegistroMemoria(FIJA,p5->getTamanio(BINARIO),offset,p5);
	b2->getAccesoDato(&offset);
//	printf("bloque2: %X\n",(unsigned int)offset);
	r4 = new RegistroMemoria(FIJA,p4->getTamanio(BINARIO),offset,p4);
	offset = (char*) offset + 60;
	r6 = new RegistroMemoria(FIJA,p6->getTamanio(BINARIO),offset,p6);
	offset = (char*) offset + 60;
	r7 = new RegistroMemoria(FIJA,p7->getTamanio(BINARIO),offset,p7);
	offset = (char*) offset + 30;
	r8 = new RegistroMemoria(FIJA,p8->getTamanio(BINARIO),offset,p8);
	
	b1->addComponente(r1);
	b1->addComponente(r2);
	b1->addComponente(r3);
	b1->addComponente(r5);
	b2->addComponente(r4);
	b2->addComponente(r6);
	b2->addComponente(r7);
	b2->addComponente(r8);
	
	char *bloque1=NULL,*bloque2=NULL;
	
	try{
		b1->escribir(BINARIO);
		b2->escribir(BINARIO);
	
		b1->leer(&bloque1,BINARIO);
		b2->leer(&bloque2,BINARIO);
	}
	catch(exception &e){
		printf("%s",e.what());
	}
	
	int i;
	for(i=0;i<TAMBLOQUE;i++)
		printf("%X",bloque1[i]);
	printf("\n");
	for(i=0;i<TAMBLOQUE;i++)
		printf("%X",bloque2[i]);
	printf("\n");
	
	// lo copio a disco para ver
	
	FILE *fp = fopen("../prueba.bin","wb+");
	fwrite(buffer,500,1,fp);
	fclose(fp);
//	*/	
	return;
	
	delete (Buffer::getInstance());
	
	delete(r1);
	delete(r2);
	delete(r3);
	delete(r4);
	delete(r5);
	delete(r6);
	delete(r7);
	delete(r8);
	delete(b1);
	delete(b2);
	delete(p1);
	delete(p2);
	delete(p3);
	delete(p4);
	delete(p5);
	delete(p6);
	delete(p7);
	delete(p8);
	cout<<"Terminado test Bloque registro"<<endl<<endl;
}


void testBloqueRegistrosDisco(){ // disco
	cout<<"Iniciando test Bloque Registro en disco"<<endl;
	Persona *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8;
	char nombre1[] = "primero", nombre2[] = "segundo", nombre3[] = "tercero",
	nombre4[] = "cuarto", nombre5[] = "quinto", nombre6[] = "sexto",
	nombre7[] = "septimo", nombre8[] = "octavo", apellido[] = "perez";
	char dni1[] = "11111111", dni2[] = "22222222", dni3[] = "33333333", dni4[] = "44444444",
	dni5[] = "55555555", dni6[] = "66666666", dni7[] = "77777777", dni8[] = "88888888";

	FILE *fp = fopen("../pruebaDisco.bin","wb+");
	
	p1 = new Persona(nombre1,apellido,dni1);
	p2 = new Persona(nombre2,apellido,dni2);
	p3 = new Persona(nombre3,apellido,dni3);
	p4 = new Persona(nombre4,apellido,dni4);
	p5 = new Persona(nombre5,apellido,dni5);
	p6 = new Persona(nombre6,apellido,dni6);
	p7 = new Persona(nombre7,apellido,dni7);
	p8 = new Persona(nombre8,apellido,dni8);
	
			
		
	/* quiero:
	 * 					bloque1						bloque2
	 * 		/---------------------------/---------------------------/
	 * 		|	|	|	|	|	|	|	|	|	|	|	|	|	|	|
	 * 		  -   1   -   3   2   5   -   4   -   6   -   7   8   -
	 *      0  30  60  90  120 150 180 210 240 270 300 330 360 390  
	 */	
	
	// en disco
	
	Bloque *b1,*b2;
	b1 = new BloqueDisco(FIJA,TAMBLOQUE,fp,1);
	fseek(fp,TAMBLOQUE,SEEK_SET);
	b2 = new BloqueDisco(FIJA,TAMBLOQUE,fp,2);
	
	printf("Bloques creados\n");
	
	Registro *r1,*r2,*r3,*r4,*r5,*r6,*r7,*r8;
	void* offset=NULL;
	FILE* otroFp;

	b1->getAccesoDato(&offset);
	otroFp = (FILE*) offset;
	fseek(fp,ftell(otroFp),SEEK_SET);
	fseek(fp,30,SEEK_CUR);
	r1 = new RegistroDisco(FIJA,p1->getTamanio(BINARIO),fp,p1);

	fseek(fp,60,SEEK_CUR);
	r3 = new RegistroDisco(FIJA,p1->getTamanio(BINARIO),fp,p3);
		
	fseek(fp,30,SEEK_CUR);
	r2 = new RegistroDisco(FIJA,p1->getTamanio(BINARIO),fp,p2);

	fseek(fp,30,SEEK_CUR);
	r5 = new RegistroDisco(FIJA,p1->getTamanio(BINARIO),fp,p5);


	b2->getAccesoDato(&offset);
	otroFp = (FILE*) offset;
	fseek(fp,ftell(otroFp),SEEK_SET);
	fseek(fp,0,SEEK_CUR);
	r4 = new RegistroDisco(FIJA,p1->getTamanio(BINARIO),fp,p4);		

	fseek(fp,60,SEEK_CUR);
	r6 = new RegistroDisco(FIJA,p1->getTamanio(BINARIO),fp,p6);
		
	fseek(fp,60,SEEK_CUR);
	r7 = new RegistroDisco(FIJA,p1->getTamanio(BINARIO),fp,p7);
	
	fseek(fp,30,SEEK_CUR);
	r8 = new RegistroDisco(FIJA,p1->getTamanio(BINARIO),fp,p8);
	
	printf("Registros creados\n");

		
	b1->addComponente(r1);
	b1->addComponente(r2);
	b1->addComponente(r3);
	b1->addComponente(r5);
	b2->addComponente(r4);
	b2->addComponente(r6);
	b2->addComponente(r7);
	b2->addComponente(r8);
	
	printf("Registros agregados a bloques\n");
	
	char *bloque1=NULL,*bloque2=NULL;
	
	try{
		b1->escribir(BINARIO);
		b2->escribir(BINARIO);
	
		b1->leer(&bloque1,BINARIO);
		b2->leer(&bloque2,BINARIO);
	}
	catch(exception &e){
		printf("%s",e.what());
	}
	
	int i;
	for(i=0;i<TAMBLOQUE;i++)
		printf("%X",bloque1[i]);
	printf("\n");
	for(i=0;i<TAMBLOQUE;i++)
		printf("%X",bloque2[i]);
	printf("\n");
	

	fclose(fp);
//	*/	
	return;
	
	delete(r1);
	delete(r2);
	delete(r3);
	delete(r4);
	delete(r5);
	delete(r6);
	delete(r7);
	delete(r8);
	delete(b1);
	delete(b2);
	delete(p1);
	delete(p2);
	delete(p3);
	delete(p4);
	delete(p5);
	delete(p6);
	delete(p7);
	delete(p8);
	cout<<"Terminado test Bloque registro"<<endl<<endl;
}



void testCubo(){
	cout<<"Iniciando test Cubo"<<endl;
	Cubo* c1=new Cubo(0,1);
	if (!c1->estaVacio()){
		cout << "Error Cubo no vacio" << endl;
	}
	c1->InsertarClave(100);
	c1->InsertarClave(200);
	c1->InsertarClave(300);
	c1->InsertarClave(400);
	c1->EliminarClave(400);

	if(c1->getClaves()->operator [](0)!=100)
		cout << "Error Cubo clave" << endl;
	if(c1->getClaves()->operator [](1)!=200)
		cout << "Error Cubo clave" << endl;
	if(c1->getClaves()->operator [](2)!=300)
		cout << "Error Cubo clave" << endl;


	delete c1;

	cout<<"Terminado test Cubo"<<endl<<endl;
}


void testCompuesto(){
	cout<<"Iniciando test Compuesto"<<endl;
	Compuesto *c = new Compuesto();
	Bloque *b1,*b2,*b3,*b4,*b5,*b6,*b7;
	char buffer[500];
	void* p = buffer;
	b1 = new BloqueMemoria(FIJA,TAMBLOQUE,1,p);
	b2 = new BloqueMemoria(FIJA,TAMBLOQUE,2,p);
	b3 = new BloqueMemoria(FIJA,TAMBLOQUE,3,p);
	b4 = new BloqueMemoria(FIJA,TAMBLOQUE,4,p);
	b5 = new BloqueMemoria(FIJA,TAMBLOQUE,5,p);
	b6 = new BloqueMemoria(FIJA,TAMBLOQUE,6,p);
	b7 = new BloqueMemoria(FIJA,TAMBLOQUE,7,p);
	c->addComponente(b1);
	c->addComponente(b2);
	c->addComponente(b3);
	c->addComponente(b4);
	c->addComponente(b5);
	c->addComponente(b6);
	c->addComponente(b7);
	int i;
	printf("\nHay %d compuestos:\n",c->getCantidadComponentes());	
	for(i=0;i<c->getCantidadComponentes();i++)
		printf("\tbloque %d = %d\n",i,c->getComponenteAt(i)->getId());	
	printf("Borro componente en posicion 5\n");
	c->deleteComponentAt(5);
	printf("\nHay %d compuestos:\n",c->getCantidadComponentes());	
	for(i=0;i<c->getCantidadComponentes();i++)
		printf("\tbloque %d = %d\n",i,c->getComponenteAt(i)->getId());	
	
	delete(c);
		
	cout<<"Terminado test Compuesto"<<endl<<endl;
}

void test_Etg_Bq_buf(){

cout<<"Iniciando test: Estrategia Bloques"<<endl;
	Persona *p1, *p2,*p3, *p4,*p5, *p6, *p7, *p8,*p9,*p10;
	 char nombre1[] = "primero", nombre2[] = "segundo", nombre3[] = "tercero", nombre4[] = "cuarto", nombre5[] = "quinto",
    nombre6[] = "sexto", nombre7[] = "septimo", nombre8[] = "octavo", nombre9[] = "noveno", nombre10[] = "decimo";
    char dni1[] = "11111111", dni2[] = "22222222", dni3[] = "33333333", dni4[] = "44444444", dni5[] = "55555555", 
    dni6[] = "66666666", dni7[] = "77777777", dni8[] = "88888888", dni9[] = "99999999", dni10[] = "10101010";
    char apellido[] = "perez";
	vector<Dato*> vecd;	
	//int *pos1=NULL, *pos2=NULL,*pos3=NULL,*pos4=NULL,*pos5=NULL, *pos6=NULL,*pos7=NULL, *pos8=NULL,*pos9=NULL, *pos10=NULL;
	
	int pos1=-1, pos2=-1,pos3=-1,pos4=-1,pos5=-1, pos6=-1,pos7=-1, pos8=-1;//,pos9=-1, pos10=-1;	
		
	p1 = new Persona(nombre1,apellido,dni1);
	p2 = new Persona(nombre2,apellido,dni2);
	p3 = new Persona(nombre3,apellido,dni3);
	p4 = new Persona(nombre4,apellido,dni4);
	p5 = new Persona(nombre5,apellido,dni5);
	p6 = new Persona(nombre6,apellido,dni6);
	p7 = new Persona(nombre7,apellido,dni7);
	p8 = new Persona(nombre8,apellido,dni8);
	p9 = new Persona(nombre9,apellido,dni9);
	p10 = new Persona(nombre10,apellido,dni10);  
	
	Buffer::getInstance()->setTamanio(512*sizeof(char));//guardo lugar para 512 bytes	
	//como tamanio de bloque es 128 voy a tener 4 bloques en buffer
		
	Almacenamiento **alm = (Almacenamiento**)malloc(2*sizeof(Almacenamiento*));//new AlmacenamientoBuffer(new Compuesto());
	
	alm[0]= new AlmacenamientoBuffer(new Compuesto());
		
	EstrategiaBloques *Ebq = new EstrategiaBloques(alm, BUFFER);	
	
	Ebq->crear(FIJA, vecd, Buffer::getInstance()->getPointer());
	printf( "cant bloques= %d\n", alm[0]->getCompuesto()->getCantidadComponentes());
	
	try{
		Ebq->insertar(p1, &pos1);
		Ebq->insertar(p2, &pos2);
		Ebq->insertar(p3, &pos3);
		Ebq->insertar(p4, &pos4);
		Ebq->insertar(p5, &pos5);
		Ebq->insertar(p6, &pos6);
		Ebq->insertar(p7, &pos7);
		Ebq->insertar(p8, &pos8);
		
		}catch(exception &e){
			printf("%s",e.what());
		}
		
		char *bufferAux = (char*) Buffer::getInstance()->getPointer();
		unsigned int i;
		printf("Buffer: ");
		for(i=0;i<Buffer::getInstance()->getTamanio();i++)
			printf("%X",bufferAux[i]);
		printf("\n");
	
		Bloque *b1,*b2,*b3,*b4;
		b1 = (Bloque*)alm[0]->getCompuesto()->getComponenteAt(0);
		printf( "cant registros en bloque 0= %d\n", b1->getCantidadComponentes());
		
		b2 = (Bloque*)alm[0]->getCompuesto()->getComponenteAt(1);
		printf( "cant registros en bloque 1= %d\n", b2->getCantidadComponentes());
		
		b3 = (Bloque*)alm[0]->getCompuesto()->getComponenteAt(2);
		printf( "cant registros en bloque 2= %d\n", b3->getCantidadComponentes());
		
		b4 = (Bloque*)alm[0]->getCompuesto()->getComponenteAt(3);
		printf( "cant registros en bloque 3= %d\n", b4->getCantidadComponentes());
		
		Persona *p11, *p12, *p13;
		char naux[]="alguno", apaux[]="perez";
		p11 = new Persona(naux,apaux,dni1);
		p12 = new Persona(naux,apaux,dni8);
		
		char n[]="demetrio",a[]="garcia";
		p13 = new Persona(n,a,dni8);
		
		printf("leo (el 1ero): \n");
		Ebq->leer(p11,0);
		p11->print();
		printf("\n");

		printf("leo (con la clave 88888888 al cual modifique previamente): \n");
		
		int nroBloque = 1;
		
		Ebq->modificar(p13,1,&nroBloque);
		Ebq->leer(p12,1);
		p12->print();printf("\n");
		
		Ebq->eliminar(p12, 1);
		
		b2 = (Bloque*)alm[0]->getCompuesto()->getComponenteAt(1);
		printf( "cant registros en bloque 1= %d\n", b2->getCantidadComponentes());
		
		delete(p1);
	delete(p2);
	delete(p3);
	delete(p4);
	delete(p5);
	delete(p6);
	delete(p7);
	delete(p8);

cout<<"Finalizando test: Estrategia Bloques"<<endl;

return;
}

void testEtgUnAlmacenamientoARBOL(){

	cout<<"Inicio test estrategia un almacenamiento"<<endl;
	
	Persona *p1, *p2,*p3, *p4,*p5, *p6, *p7, *p8,*p9,*p10;
	 char nombre1[] = "primero", nombre2[] = "segundo", nombre3[] = "tercero", nombre4[] = "cuarto", nombre5[] = "quinto",
    nombre6[] = "sexto", nombre7[] = "septimo", nombre8[] = "octavo", nombre9[] = "noveno", nombre10[] = "decimo";
    char dni1[] = "11111111", dni2[] = "22222222", dni3[] = "33333333", dni4[] = "44444444", dni5[] = "55555555", 
    dni6[] = "66666666", dni7[] = "77777777", dni8[] = "88888888", dni9[] = "99999999", dni10[] = "10101010";
    char apellido[] = "perez";
	vector<Dato*> vecd;	
	
	//int pos1=-1, pos2=-1,pos3=-1,pos4=-1,pos5=-1, pos6=-1,pos7=-1, pos8=-1,pos9=-1, pos10=-1;	
		
	p1 = new Persona(nombre1,apellido,dni1);
	p2 = new Persona(nombre2,apellido,dni2);
	p3 = new Persona(nombre3,apellido,dni3);
	p4 = new Persona(nombre4,apellido,dni4);
	p5 = new Persona(nombre5,apellido,dni5);
	p6 = new Persona(nombre6,apellido,dni6);
	p7 = new Persona(nombre7,apellido,dni7);
	p8 = new Persona(nombre8,apellido,dni8);
	p9 = new Persona(nombre9,apellido,dni9);
	p10 = new Persona(nombre10,apellido,dni10);  
	
	Buffer::getInstance()->setTamanio(512*sizeof(char));//guardo lugar para 512 bytes	
	
	PrimaryKeyPersona *PK = new PrimaryKeyPersona();
	
	//EstrategiaIndice *indice= new  IndiceArbolB(PK);
	
	Almacenamiento **almacenamiento = (Almacenamiento**)malloc(2*sizeof(Almacenamiento*));
	
	almacenamiento[0]= new AlmacenamientoBuffer(new Compuesto());
	
	void *ptr= Buffer::getInstance()->getPointer();	
	
	EtgRecUnAlmacenamiento *etg_un_a = new EtgRecUnAlmacenamiento(FIJA,ARBOL/*,indice*/,BUFFER,BLOQUES,almacenamiento,ptr,PK);
  
  	try{
  		etg_un_a->insertar(p1);
  		etg_un_a->insertar(p2);
  		etg_un_a->insertar(p3);
  		etg_un_a->insertar(p4);
  		etg_un_a->insertar(p5);
  	}catch(exception &e){
  		cout<< e.what()<<endl;
  	}
  	
  	char *bufferAux = (char*) Buffer::getInstance()->getPointer();
		unsigned int i;
		printf("Buffer: ");
		for(i=0;i<Buffer::getInstance()->getTamanio();i++)
			printf("%X",bufferAux[i]);
		printf("\n");
	
		Bloque *b1,*b2,*b3,*b4;
		b1 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(0);
		printf( "cant registros en bloque 0= %d\n", b1->getCantidadComponentes());
		
		b2 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(1);
		printf( "cant registros en bloque 1= %d\n", b2->getCantidadComponentes());
		
		b3 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(2);
		printf( "cant registros en bloque 2= %d\n", b3->getCantidadComponentes());
		
		b4 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(3);
		printf( "cant registros en bloque 3= %d\n", b4->getCantidadComponentes());
  	
  	Persona *p11;
  	char n[]="", a[]="";
  	p11 = new Persona(n,a,dni4);
  	etg_un_a->leer(p11);
  	p11->print();
  	printf("\n");
  	Persona *p12;
  	char no[]="hugo", ap[]="juarez";
  	p12 = new Persona(no,ap,dni4);
  	etg_un_a->modificar(p12);
  	etg_un_a->leer(p11);
  	p11->print();
  printf("\n");
  	
  	etg_un_a->eliminar(p12);
  	b1 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(0);
	printf( "SE Q ESTA ACA: cant registros en bloque 0= %d\n", b1->getCantidadComponentes());
  	
	delete(p1);
	delete(p2);
	delete(p3);
	delete(p4);
	delete(p5);
	delete(p6);
	delete(p7);
	delete(p8);
	

	cout<<"Finalizando test estrategia un almacenamiento"<<endl;
	return;
}


void testEtgUnAlmacenamientoHASH(){

	cout<<"Inicio test estrategia un almacenamiento con hash"<<endl;
	
	Persona *p1, *p2,*p3, *p4,*p5, *p6, *p7, *p8,*p9,*p10;
	 char nombre1[] = "primero", nombre2[] = "segundo", nombre3[] = "tercero", nombre4[] = "cuarto", nombre5[] = "quinto",
    nombre6[] = "sexto", nombre7[] = "septimo", nombre8[] = "octavo", nombre9[] = "noveno", nombre10[] = "decimo";
    char dni1[] = "11111111", dni2[] = "22222222", dni3[] = "33333333", dni4[] = "44444444", dni5[] = "55555555", 
    dni6[] = "66666666", dni7[] = "77777777", dni8[] = "88888888", dni9[] = "99999999", dni10[] = "10101010";
    char apellido[] = "perez";
	vector<Dato*> vecd;	
	
	//int pos1=-1, pos2=-1,pos3=-1,pos4=-1,pos5=-1, pos6=-1,pint datosAEscribir = this->dato->getTamanio(modo);os7=-1, pos8=-1,pos9=-1, pos10=-1;	
		
	p1 = new Persona(nombre1,apellido,dni1);
	p2 = new Persona(nombre2,apellido,dni2);
	p3 = new Persona(nombre3,apellido,dni3);
	p4 = new Persona(nombre4,apellido,dni4);
	p5 = new Persona(nombre5,apellido,dni5);
	p6 = new Persona(nombre6,apellido,dni6);
	p7 = new Persona(nombre7,apellido,dni7);
	p8 = new Persona(nombre8,apellido,dni8);
	p9 = new Persona(nombre9,apellido,dni9);
	p10 = new Persona(nombre10,apellido,dni10);  
	
	Buffer::getInstance()->setTamanio(512*sizeof(char));//guardo lugar para 512 bytes	
	
	PrimaryKeyPersona *PK = new PrimaryKeyPersona();
	
	//EstrategiaIndice *indice= new  IndiceArbolB(PK);
	
	Almacenamiento **almacenamiento = (Almacenamiento**)malloc(2*sizeof(Almacenamiento*));
	
	almacenamiento[0]= new AlmacenamientoBuffer(new Compuesto());
	
	void *ptr= Buffer::getInstance()->getPointer();	
	
	EtgRecUnAlmacenamiento *etg_un_a = new EtgRecUnAlmacenamiento(FIJA,HASH/*,indice*/,BUFFER,BLOQUES,almacenamiento,ptr,PK);
  
  	try{
  		etg_un_a->insertar(p1);
  		etg_un_a->insertar(p2);
  		etg_un_a->insertar(p3);
  		etg_un_a->insertar(p4);
  		etg_un_a->insertar(p5);
  		etg_un_a->insertar(p6);
  		etg_un_a->insertar(p7);
  		etg_un_a->insertar(p8);
  		etg_un_a->insertar(p9);
  		etg_un_a->insertar(p10);
  	}catch(exception &e){
  		cout<< e.what()<<endl;
  	}
  	
	  	char *bufferAux = (char*) Buffer::getInstance()->getPointer();
		unsigned int i;
		printf("Buffer: ");
		for(i=0;i<Buffer::getInstance()->getTamanio();i++)
			printf("%X",bufferAux[i]);
		printf("\n");

		Bloque *b1,*b2,*b3,*b4;
		b1 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(0);
		printf( "cant registros en bloque 0= %d\n", b1->getCantidadComponentes());
		
		b2 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(1);
		printf( "cant registros en bloque 1= %d\n", b2->getCantidadComponentes());
		
		b3 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(2);
		printf( "cant registros en bloque 2= %d\n", b3->getCantidadComponentes());
		
		b4 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(3);
		printf( "cant registros en bloque 3= %d\n", b4->getCantidadComponentes());
  	
  	  	
  	Persona *p11;
  	char n[]="", a[]="";
  	p11 = new Persona(n,a,dni4);
  	etg_un_a->leer(p11);
  	p11->print();
  	printf("\n");
  	Persona *p12;
 
 	char no[]="hugo", ap[]="juarez";
  	p12 = new Persona(no,ap,dni4);
 	etg_un_a->modificar(p12);
  	printf("modificacion: ");
  	etg_un_a->leer(p11);
  	p11->print();
  	printf("\n");

  	
  	etg_un_a->eliminar(p12);
  	b1 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(0);
	
  	b1 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(0);
	printf( "cant registros en bloque 0= %d\n", b1->getCantidadComponentes());
		
	b2 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(1);
	printf( "cant registros en bloque 1= %d\n", b2->getCantidadComponentes());
		
	b3 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(2);
	printf( "cant registros en bloque 2= %d\n", b3->getCantidadComponentes());
		
	b4 = (Bloque*)almacenamiento[0]->getCompuesto()->getComponenteAt(3);
	printf( "cant registros en bloque 3= %d\n", b4->getCantidadComponentes());
  	
  	delete(Buffer::getInstance());
  	delete(etg_un_a);
	delete(p1);
	delete(p2);
	delete(p3);
	delete(p4);
	delete(p5);
	delete(p6);
	delete(p7);
	delete(p8);
	

	cout<<"Finalizando test estrategia un almacenamiento  con hash"<<endl;
	return;
}



int main(){

/**
 * No se pueden correr todos juntos debido a la clase Buffer que es Singleton
 * */
//	testBloqueRegistros();
//	testBloqueRegistrosDisco();
//	test_Est_Reg_Buf_Fija();
//	test_Etg_Bq_buf();
//	testCubo();
//	testCompuesto();
//	testEtgUnAlmacenamientoARBOL();

//	testEtgUnAlmacenamientoHASH();
	testAB();
	testAD();

	cout<<"\nTermino el test"<<endl;
	return 0;
}

